home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / vidhrdw / gladiatr.c < prev    next >
C/C++ Source or Header  |  2000-04-04  |  7KB  |  279 lines
  1.  
  2.  
  3. /***************************************************************************
  4.     Video Hardware description for Taito Gladiator
  5.  
  6. ***************************************************************************/
  7. #include "driver.h"
  8. #include "vidhrdw/generic.h"
  9.  
  10. static int video_attributes;
  11. static int base_scroll;
  12. static int background_scroll;
  13. static int sprite_bank;
  14.  
  15. unsigned char *gladiatr_scroll;
  16. unsigned char *gladiator_text;
  17.  
  18.  
  19. static void update_color(int offset)
  20. {
  21.     int r,g,b;
  22.  
  23.  
  24.     r = (paletteram[offset] >> 0) & 0x0f;
  25.     g = (paletteram[offset] >> 4) & 0x0f;
  26.     b = (paletteram_2[offset] >> 0) & 0x0f;
  27.  
  28.     r = (r << 1) + ((paletteram_2[offset] >> 4) & 0x01);
  29.     g = (g << 1) + ((paletteram_2[offset] >> 5) & 0x01);
  30.     b = (b << 1) + ((paletteram_2[offset] >> 6) & 0x01);
  31.  
  32.     r = (r << 3) | (r >> 2);
  33.     g = (g << 3) | (g >> 2);
  34.     b = (b << 3) | (b >> 2);
  35.  
  36.     palette_change_color(offset,r,g,b);
  37.  
  38.     /* the text layer might use the other 512 entries in the palette RAM */
  39.     /* (which are all set to 0x07ff = white). I don't know, so I just set */
  40.     /* it to white. */
  41.     palette_change_color(512,0x00,0x00,0x00);
  42.     palette_change_color(513,0xff,0xff,0xff);
  43. }
  44.  
  45. WRITE_HANDLER( gladiatr_paletteram_rg_w )
  46. {
  47.     paletteram[offset] = data;
  48.     update_color(offset);
  49. }
  50.  
  51. WRITE_HANDLER( gladiatr_paletteram_b_w )
  52. {
  53.     paletteram_2[offset] = data;
  54.     update_color(offset);
  55. }
  56.  
  57.  
  58. WRITE_HANDLER( gladiatr_spritebank_w );
  59. WRITE_HANDLER( gladiatr_spritebank_w ){
  60.     sprite_bank = (data)?4:2;
  61. }
  62.  
  63. READ_HANDLER( gladiatr_video_registers_r );
  64. READ_HANDLER( gladiatr_video_registers_r ){
  65.     switch( offset ){
  66.         case 0x080: return video_attributes;
  67.         case 0x100: return base_scroll;
  68.         case 0x300: return background_scroll;
  69.     }
  70.     return 0;
  71. }
  72.  
  73. WRITE_HANDLER( gladiatr_video_registers_w );
  74. WRITE_HANDLER( gladiatr_video_registers_w ){
  75.     switch( offset ){
  76.         case 0x000: break;
  77.         case 0x080: video_attributes = data; break;
  78.         case 0x100: base_scroll = data; break;
  79.         case 0x200: break;
  80.         case 0x300: background_scroll = data; break;
  81.     }
  82. }
  83.  
  84.  
  85. int gladiatr_vh_start(void);
  86. int gladiatr_vh_start(void){
  87.     sprite_bank = 2;
  88.  
  89.     dirtybuffer = malloc(64*32);
  90.     if( dirtybuffer ){
  91.         tmpbitmap = osd_new_bitmap( 512,256, Machine->scrbitmap->depth );
  92.         if( tmpbitmap ){
  93.             memset(dirtybuffer,1,64*32);
  94.             return 0;
  95.         }
  96.         free( dirtybuffer );
  97.     }
  98.     return 1; /* error */
  99. }
  100.  
  101. void gladiatr_vh_stop(void);
  102. void gladiatr_vh_stop(void){
  103.     osd_free_bitmap(tmpbitmap);
  104.     free(dirtybuffer);
  105. }
  106.  
  107.  
  108. static void render_background( struct osd_bitmap *bitmap );
  109. static void render_background( struct osd_bitmap *bitmap ){
  110.     int i;
  111.     static int tile_bank_select = 0;
  112.  
  113.     int scrollx = - background_scroll;
  114.  
  115.     if( base_scroll < 0xd0 ){
  116.         scrollx += 256-(0xd0)-64-32;
  117.  
  118.         if( video_attributes&0x04 ){
  119.             scrollx += 256;
  120.         }
  121.     }
  122.     else {
  123.         if( video_attributes&0x04 ){
  124.             scrollx += base_scroll;
  125.         }
  126.         else {
  127.             scrollx += 256-(0xd0)-64-32;
  128.         }
  129.     }
  130.  
  131.     {
  132.         int old_bank_select = tile_bank_select;
  133.         if( video_attributes & 0x10 ){
  134.             tile_bank_select = 256*8;
  135.         }
  136.         else {
  137.             tile_bank_select = 0;
  138.         }
  139.         if( old_bank_select != tile_bank_select )
  140.             memset(dirtybuffer,1,64*32);
  141.     }
  142.  
  143.     for( i=0; i<64*32; i++ ){
  144.         if( dirtybuffer[i] ){
  145.             int sx = (i%64)*8;
  146.             int sy = (i/64)*8;
  147.  
  148.             int attributes = colorram[i];
  149.             int color = 0x1F - (attributes>>3);
  150.             int tile_number = videoram[i] + 256*(attributes&0x7) + tile_bank_select;
  151.  
  152.             drawgfx(tmpbitmap,Machine->gfx[1+(tile_number/512)],
  153.                 tile_number%512,
  154.                 color,
  155.                 0,0, /* no flip */
  156.                 sx,sy,
  157.                 0, /* no need to clip */
  158.                 TRANSPARENCY_NONE,0);
  159.  
  160.             dirtybuffer[i] = 0;
  161.         }
  162.     }
  163.  
  164.     copyscrollbitmap(bitmap,tmpbitmap,
  165.         1,&scrollx,
  166.         0,0,
  167.         &Machine->drv->visible_area,TRANSPARENCY_NONE,0);
  168. }
  169.  
  170. static void render_text( struct osd_bitmap *bitmap );
  171. static void render_text( struct osd_bitmap *bitmap ){
  172.     const struct rectangle *clip = &Machine->drv->visible_area;
  173.     const struct GfxElement *gfx = Machine->gfx[0];
  174.  
  175.     int tile_bank_offset = (video_attributes&3)*256;
  176.  
  177.     unsigned char *source = gladiator_text;
  178.  
  179.     int sx,sy;
  180.  
  181.     int dx;
  182.  
  183.     if( base_scroll < 0xd0 ){ /* panning text */
  184.         dx = 256-(0xd0)-64-32- background_scroll;
  185.         if( video_attributes&0x04 ){ dx += 256; }
  186.     }
  187.     else { /* fixed text */
  188.         dx = 0;
  189.         if( (video_attributes&0x08)==0 ) source += 32; /* page 2 */
  190.     }
  191.  
  192.     for( sy=0; sy<256; sy+=8 ){
  193.         for( sx=0; sx<256; sx+=8 ){
  194.             drawgfx( bitmap,gfx,
  195.                 tile_bank_offset + *source++,
  196.                 0, /* color */
  197.                 0,0, /* no flip */
  198.                 sx+dx,sy,
  199.                 clip,TRANSPARENCY_PEN,0);
  200.         }
  201.         source += 32; /* skip to next row */
  202.     }
  203. }
  204.  
  205. static void draw_sprite( struct osd_bitmap *bitmap, int tile_number, int color, int sx, int sy, int xflip, int yflip, int big );
  206. static void draw_sprite( struct osd_bitmap *bitmap, int tile_number, int color, int sx, int sy, int xflip, int yflip, int big ){
  207.     const struct rectangle *clip = &Machine->drv->visible_area;
  208.  
  209.     static int tile_offset[4][4] = {
  210.         {0x0,0x1,0x4,0x5},
  211.         {0x2,0x3,0x6,0x7},
  212.         {0x8,0x9,0xC,0xD},
  213.         {0xA,0xB,0xE,0xF}
  214.     };
  215.  
  216.     int x,y;
  217.  
  218.     int size = big?4:2;
  219.  
  220.     for( y=0; y<size; y++ ){
  221.         for( x=0; x<size; x++ ){
  222.             int ex = xflip?(size-1-x):x;
  223.             int ey = yflip?(size-1-y):y;
  224.  
  225.             int t = tile_offset[ey][ex] + tile_number;
  226.  
  227.             drawgfx(bitmap,Machine->gfx[1+8+((t/512)%12)],
  228.                 t%512,
  229.  
  230.                 color,
  231.                 xflip,yflip,
  232.                 sx+x*8,sy+y*8,
  233.                 clip,TRANSPARENCY_PEN,0);
  234.         }
  235.     }
  236. }
  237.  
  238. static void render_sprites(struct osd_bitmap *bitmap);
  239. static void render_sprites(struct osd_bitmap *bitmap){
  240.     unsigned char *source = spriteram;
  241.     unsigned char *finish = source+0x400;
  242.  
  243.     do{
  244.         int attributes = source[0x800];
  245.         int big = attributes&0x10;
  246.         int bank = (attributes&0x1) + ((attributes&2)?sprite_bank:0);
  247.         int tile_number = (source[0]+256*bank)*4;
  248.         int sx = source[0x400+1] + 256*(source[0x801]&1);
  249.         int sy = 240-source[0x400] - (big?16:0);
  250.         int xflip = attributes&0x04;
  251.         int yflip = attributes&0x08;
  252.         int color = 0x20 + (source[1]&0x1F);
  253.  
  254.         if( (video_attributes & 0x04) && (base_scroll < 0xd0) )
  255.             sx += 256-64+8-0xD0-64+8;
  256.         else
  257.             sx += base_scroll-0xD0-64+8;
  258.  
  259.         draw_sprite( bitmap, tile_number, color, sx,sy, xflip,yflip, big );
  260.  
  261.         source+=2;
  262.     }while( source<finish );
  263. }
  264.  
  265.  
  266.  
  267. void gladiatr_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
  268. {
  269.     if (video_attributes & 0x20)    /* screen refresh enable? */
  270.     {
  271.         if (palette_recalc())
  272.             memset(dirtybuffer,1,64*32);
  273.  
  274.         render_background( bitmap );
  275.         render_sprites( bitmap );
  276.         render_text( bitmap );
  277.     }
  278. }
  279.